/*Copyright (C) 2009 - 2011 MASSART GAUTHIER and Careil Baptiste

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/


#include "../headers.h"

#define TAILLE_MAX 1000

void vider_buffer(void) {
	if(CSLP_PollChar()) {
		while(CSLP_PollChar()) {
			getch();
		}
	}
}

int determiner_direction(long touche_appuyee) {

	if(touche_appuyee == touche_haut) {
		return -50;
	}
	else if(touche_appuyee == touche_gauche) {
		return -1;
	}
	else if(touche_appuyee == touche_bas) {
		return 50;
	}
	else if(touche_appuyee == touche_droite) {
		return 1;
	}
	else {
		return 0;
	}

}

int type_mvt_snake(char PositionNext) {
	if(PositionNext == ' ') {
		return 1;
	}
	else if(PositionNext == 'o') {
		return 2;
	}
	else if(PositionNext == 'O') {
		return 3;
	}
	else if(PositionNext == '#' || PositionNext == '=') {
		return 4;
	}
	else if(PositionNext == 'C') {
		return 5;
	}
	else {
		return 0;
	}
}

int type_mvt_excit(char PositionNext) {
	if(PositionNext == ' ') {
		return 1;
	}
	else if(PositionNext == '_' || PositionNext == '|') {
		return 2;
	}
	else if(PositionNext == 'O') {
		return 3;
	}
	else if(PositionNext == '#') {
		return 4;
	}
	else {
		return 0;
	}
}

void lire_conf(void) {

	if(fichier_existe(CONFIG_FILENAME)) {

		long stop, aleatoire;
		char nom[10];

		/* lecture de chaines */
		ini_gets("Nom", "joueur_1", "aap", prenom, sizearray(prenom), CONFIG_FILENAME);
		ini_gets("Couleurs", "couleur_texte", "aap", nom, sizearray(nom), CONFIG_FILENAME);
		CT = couleur_nom(nom);
		ini_gets("Couleurs", "couleur_saisie", "aap", nom, sizearray(nom), CONFIG_FILENAME);
		CS = couleur_nom(nom);
		ini_gets("Couleurs", "couleur_sélection", "aap", nom, sizearray(nom), CONFIG_FILENAME);
		CTS = couleur_nom(nom);
		ini_gets("Couleurs", "couleur_fond", "aap", nom, sizearray(nom), CONFIG_FILENAME);
		CBS = couleur_nom(nom);

		/* lecture de valeurs */
		volume_musique = ini_getl("Musique", "volume_musique", -1, CONFIG_FILENAME);
		volume_son = ini_getl("Musique", "volume_son", -1, CONFIG_FILENAME);
		CSLP_Sleep(100); // Pour que le changement soit effectif
		aleatoire = ini_getl("Musique", "aléatoire/continue", -1, CONFIG_FILENAME);
		stop = ini_getl("Musique", "marche/arrêt", -1, CONFIG_FILENAME);
		touche_haut = ini_getl("Touches", "touche_haut",  -1, CONFIG_FILENAME);
		touche_bas = ini_getl("Touches", "touche_bas",  -1, CONFIG_FILENAME);
		touche_droite = ini_getl("Touches", "touche_droite",  -1, CONFIG_FILENAME);
		touche_gauche = ini_getl("Touches", "touche_gauche",  -1, CONFIG_FILENAME);
		type_menu = ini_getl("Menu", "type",  -1, CONFIG_FILENAME);
		animation_menu = ini_getl("Menu", "animation",  -1, CONFIG_FILENAME);
		animations_bienvenue_fin = ini_getl("Animations", "Bienvenue/Fin",  -1, CONFIG_FILENAME);
		verif_maj_start = ini_getl("Démarrage", "maj", -1, CONFIG_FILENAME);
		/*si le volume est plus grand que 125 on le rabaisse à 120*/
		if(volume_musique > 125) {
			volume_musique = 125;
		}
		if(volume_son > 125) {
			volume_son = 125;
		}

		/*si le volume n'est pas un multible de 5*/
		if(volume_musique % 5 != 0) {
			/*on l'arondie au multiple de 5 en dessous*/
			volume_musique -= volume_musique % 5;
		}
		if(volume_son % 5 != 0) {
			volume_son -= volume_son % 5;
		}

		if(stop)
			stop_music(true);
		else
			stop_music(false);

		if(aleatoire)
			music_set_mode_shuffle(true);
		else
			music_set_mode_shuffle(false);
	}
	else {
		short k = 0;
		beep();
		clear();
		afficher_titre("PREMIER LANCEMENT : INFO UTILISATEUR");
		CSLP_ColorText(COLOR_WHITE);

		editer_chaine(20, 20, 0, "Entrez votre nom :  ", prenom);

		while(k != KEY_RETURN || prenom[0] == '\0') {
			k = KEY_RETURN;
			editer_chaine(20, 20, k, "Entrez votre nom :  ", prenom);
		}

		clear();
		options();
		clear();
		modif_conf();
#ifdef WIN32
		anim_fenetre_jeu();
#endif

	}
}

void modif_conf(void) {
	char nom[10];

	/* écriture de chaines */
	ini_puts("Nom", "joueur_1", prenom, CONFIG_FILENAME);
	nom_couleur(CT, nom);
	ini_puts("Couleurs", "couleur_texte", nom, CONFIG_FILENAME);
	nom_couleur(CS, nom);
	ini_puts("Couleurs", "couleur_saisie", nom, CONFIG_FILENAME);
	nom_couleur(CTS, nom);
	ini_puts("Couleurs", "couleur_sélection", nom, CONFIG_FILENAME);
	nom_couleur(CBS, nom);
	ini_puts("Couleurs", "couleur_fond", nom, CONFIG_FILENAME);

	/* écriture de valeurs */
	ini_putl("Musique", "volume_musique", volume_musique, CONFIG_FILENAME);
	ini_putl("Musique", "volume_son", volume_son, CONFIG_FILENAME);
	ini_putl("Musique", "aléatoire/continue", music_get_mode_shuffle(), CONFIG_FILENAME);
	ini_putl("Musique", "marche/arrêt", is_music_stoped(), CONFIG_FILENAME);
	ini_putl("Touches", "touche_haut", touche_haut, CONFIG_FILENAME);
	ini_putl("Touches", "touche_bas", touche_bas, CONFIG_FILENAME);
	ini_putl("Touches", "touche_droite", touche_droite, CONFIG_FILENAME);
	ini_putl("Touches", "touche_gauche", touche_gauche, CONFIG_FILENAME);
	ini_putl("Menu", "type", type_menu, CONFIG_FILENAME);
	ini_putl("Menu", "animation", animation_menu, CONFIG_FILENAME);
	ini_putl("Animations", "Bienvenue/Fin", animations_bienvenue_fin, CONFIG_FILENAME);
	ini_putl("Démarrage", "maj", verif_maj_start, CONFIG_FILENAME);

	lire_conf();
}

void afficher_char_fullblock(int nb, int couleur) {
	while(nb > 0) {
		if(couleur != 0) {
			CSLP_ColorText(couleur);
			addstr("\xE2\x96\x88");
		}
		else {
			addch(' ');
		}
		nb--;
	}
}

void afficher_char_bullet(int nb) {
	while(nb > 0) {
		addstr("\xE2\x80\xA2");
		nb--;
	}
}

int compter_score(char *fichierAOuvrir) {
	char nom_section_score[20] = "Score_1", texte[100];
	int nombre_scrore = 1;

	if(fichier_existe(fichierAOuvrir) == true) {
		do {
			sprintf(nom_section_score, "Score_%d", nombre_scrore);
			ini_gets(nom_section_score, "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
			nombre_scrore++;
		}
		while(strcmp(texte, "aap"));

		nombre_scrore--;
	}

	return nombre_scrore;
}

void save_score(char jeu[20], long v1, long v2, char texte1[100]) {
	char fichierAOuvrir[50] = "scores/", nom_section_score[20];
	strcat(fichierAOuvrir, jeu);
	strcat(fichierAOuvrir, "Scores.sav");

	if(!strcmp(jeu, "PlusOuMoinsPN")) {
		if(v2 != 6) {
			sprintf(nom_section_score, "Score_%d", compter_score(fichierAOuvrir));
			ini_puts(nom_section_score, "joueur", prenom, fichierAOuvrir);
			ini_putl(nom_section_score, "tours", v1, fichierAOuvrir);
			ini_putl(nom_section_score, "niveau", v2, fichierAOuvrir);
		}
	}
	else if(!strcmp(jeu, "PlusOuMoinsPAC")) {
		if(v2 != 6) {
			sprintf(nom_section_score, "Score_%d", compter_score(fichierAOuvrir));
			ini_puts(nom_section_score, "joueur", prenom, fichierAOuvrir);
			ini_putl(nom_section_score, "tours", v1, fichierAOuvrir);
			ini_putl(nom_section_score, "niveau", v2, fichierAOuvrir);
		}
	}
	else if(!strcmp(jeu, "PlusOuMoinsMA")) {
		sprintf(nom_section_score, "Score_%d", compter_score(fichierAOuvrir));
		ini_puts(nom_section_score, "joueur", prenom, fichierAOuvrir);
		ini_putl(nom_section_score, "tours", v1, fichierAOuvrir);
		ini_putl(nom_section_score, "niveau", v2, fichierAOuvrir);
	}
	else if(!strcmp(jeu, "Pendu")) {
		ini_puts(texte1, "joueur", prenom, fichierAOuvrir);
		ini_putl(texte1, "fautes", v1, fichierAOuvrir);
	}
	else if(!strcmp(jeu, "Snake")) {
		ini_puts(texte1, "joueur", prenom, fichierAOuvrir);
		ini_putl(texte1, "points", v1, fichierAOuvrir);
		ini_putl(texte1, "millisecondes", v2, fichierAOuvrir);
	}
	else if(!strcmp(jeu, "Tetris")) {
		ini_puts("Score_1", "joueur", prenom, fichierAOuvrir);
		ini_putl("Score_1", "points", (v1 + 840) / 2, fichierAOuvrir);
	}
	else if(!strcmp(jeu, "Excit")) {
		ini_puts(texte1, "joueur", prenom, fichierAOuvrir);
		ini_putl(texte1, "temps", (v1 + 840) / 2, fichierAOuvrir);
	}
	else {
		addstr(" ERREUR! Ce jeu n'existe pas!");
		getch();
	}

	refresh();
}

long lire_suppr_score(char jeu[20], bool lire) {

	char fichierAOuvrir[50] = "scores/", texte[100], sections[1000][100] = {{0}}, nom_section_score[20];
	long v1, v2, v3;
	int nombre_score = 0, i = 1;
	strcat(fichierAOuvrir, jeu);
	strcat(fichierAOuvrir, "Scores.sav");

	if(!lire)
		remove(fichierAOuvrir);
	else {

		if(fichier_existe(fichierAOuvrir)) {

			if(!strcmp(jeu, "PlusOuMoinsPN")) {
				nombre_score = compter_score(fichierAOuvrir);

				while(i != nombre_score) {
					sprintf(nom_section_score, "Score_%d", i);
					ini_gets(nom_section_score, "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v1 = ini_getl(nom_section_score, "tours", -1, fichierAOuvrir);
					v2 = ini_getl(nom_section_score, "niveau", -1, fichierAOuvrir);
					printw("\n\n %s a gagné en %ld tour(s) dans une partie normale au niveau %ld!", texte, v1, v2);
					i++;
				}
			}
			else if(!strcmp(jeu, "PlusOuMoinsPAC")) {
				nombre_score = compter_score(fichierAOuvrir);

				while(i != nombre_score) {
					ini_gets("Score_1", "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v1 = ini_getl("Score_1", "tours", -1, fichierAOuvrir);
					v2 = ini_getl("Score_1", "niveau", -1, fichierAOuvrir);
					printw("\n\n %s a gagné en %ld tour(s) dans une partie à coups limités au niveau %ld!", texte, v1, v2);
					i++;
				}
			}
			else if(!strcmp(jeu, "PlusOuMoinsMA")) {
				nombre_score = compter_score(fichierAOuvrir);

				while(i != nombre_score) {
					ini_gets("Score_1", "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v1 = ini_getl("Score_1", "tours", -1, fichierAOuvrir);
					v2 = ini_getl("Score_1", "niveau", -1, fichierAOuvrir);
					printw("\n\n %s a gagné en %ld tour(s) dans le mode aventure au niveau %ld!", texte, v1, v2);
					i++;
				}
			}
			else if(!strcmp(jeu, "Pendu")) {
				for(v3 = 0; ini_getsection(v3, texte, sizearray(texte), fichierAOuvrir) > 0; v3++) {
					strcat(sections[v3], texte);
				}

				for(v3 = 0; sections[v3][0] != 0; v3++) {
					ini_gets(sections[v3], "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v2 = ini_getl(sections[v3], "fautes", -1, fichierAOuvrir);
					printw("\n\n %s a trouvé le mot %s en faisant %ld fautes!", texte, sections[v3], v2);
				}
			}
			else if(!strcmp(jeu, "Snake")) {
				for(v3 = 0; ini_getsection(v3, texte, sizearray(texte), fichierAOuvrir) > 0; v3++) {
					strcat(sections[v3], texte);
				}

				for(v3 = 0; sections[v3][0] != 0; v3++) {
					ini_gets(sections[v3], "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v1 = ini_getl(sections[v3], "points", -1, fichierAOuvrir);
					v2 = ini_getl(sections[v3], "millisecondes", -1, fichierAOuvrir);
					printw("\n\n %s a fini le pack de nivaux : %s avec %ld point(s)\n à la vitesse de 1 déplacement toutes les %ld millisecondes !", texte, sections[v3], v1, v2);
				}
			}
			else if(!strcmp(jeu, "Tetris")) {
				ini_gets("Score_1", "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
				v1 = ini_getl("Score_1", "points", -1, fichierAOuvrir);
				addstr(texte);

				if(v1 * 2 - 840 != -842)
					return v1 * 2 - 840;
				else
					return -1;
			}
			else if(!strcmp(jeu, "Excit")) {
				for(v3 = 0; ini_getsection(v3, texte, sizearray(texte), fichierAOuvrir) > 0; v3++) {
					strcat(sections[v3], texte);
				}

				for(v3 = 0; sections[v3][0] != 0; v3++) {
					ini_gets(sections[v3], "joueur", "aap", texte, sizearray(texte), fichierAOuvrir);
					v1 = ini_getl(sections[v3], "temps", -1, fichierAOuvrir);
					printw("\n\n %s a finit le pack de niveau : %s en %ld min %ld, %ld sec !", texte, sections[v3], (v1 * 2 - 840) / 60000, ((v1 * 2 - 840) / 1000) % 60, (v1 * 2 - 840) % 1000);
				}
			}
			else {
				addstr(" ERREUR! Ce jeu n'existe pas!");
			}
		}
		else {
			printw(" Impossible d'ouvrir le fichier %s", fichierAOuvrir);
			refresh();
			return -1;
		}
	}

	return 0;
}

/* Cette fonction permet de simplifier l'affichage des caractères contenus dans matrice[]
** Tout d'abord on envoi la matrice, ensuite on donne l'intervale de cases de matrice[] que l'on veut afficher.
** char begin est un tableau de char qu'on affiche en début de fonction.
** char end[] est un tableau de char qu'on affichera à la fin de la fonction.
** Dans la fonction un nouveau tableau est créé contenant les caractères de mat[] qu'on veut afficher et c'est celui-là qui va être affiché.
*/
void affichage_mat(char mat[], short min, short max, char begin[], char end[]) {
	char *mat_ = malloc(sizeof(char) * (max - min + 1));
	short i;

	addstr(begin);

	for(i = 0 ; i < max - min ; i++) {
		mat_[i] = mat[min + i];
	}

	mat_[i + 1] = '\0';

	addstr(mat_);
	addstr(end);
	refresh();

	free(mat_);
}

int afficher_barre(long debut, long fin, long saut, long variable) {
	int i, touche_appuyee = 0, espaces;

	CSLP_Color(COLOR_BLACK, COLOR_BLACK);
	addstr("\n\n");
	i  = 0;
	espaces = ceil(DEFAULT_SCREEN_SIZE_X / 2 - (fin - debut) / (saut * 2) - 8);

	while(espaces != i) {
		addch(' ');
		i++;
	}

	addstr("[-] ");

	for(i = debut; i <= fin; i += saut) {
		if(i != variable) {
			addstr("_");
		}
		else {
			addstr("▲");
		}
	}

	addstr(" [+]");

	CSLP_ColorText(COLOR_RED);
	printw(" %li  \n\n", variable);
	afficher_centre("Quand vous aurez terminé, appuyez sur ENTREE");
	CSLP_ColorText(CT);
	touche_appuyee = getch();

	return touche_appuyee;
}

long afficher_barre_full(long debut, long fin, long saut, long variable) {

	int i, touche_appuyee = 0;

	while(touche_appuyee != '\r' && touche_appuyee != '\n' && touche_appuyee != '\b') {

		touche_appuyee = afficher_barre(debut, fin, saut, variable);

		if(touche_appuyee == KEY_RIGHT && variable != fin) {
			variable += saut;
		}
		else if(touche_appuyee == KEY_LEFT && variable > debut) {
			variable -= saut;
		}

		for(i = 0; i != 5 ; i++) {
			goto_previous_line();
		}

		goto_begin_line();
	}

	return variable;
}

/* Une fonction pour afficher une chaine de caractères avec support de l'UTF-8 PARTIEL (plages du latin-1 et Box-drawing)
** On envoi tout d'abord la chaine
** Ensuite on définit où doit se trouver le curseur: col pour les x, row pour les y
** Le sens (sens "normal" ou "inverse") se définit avec l'argument dir
** Enfin la direction avec cross, 1 pour horizontale et 0 pour verticale
** Dans le fonctionnement "inverse" du balayage le curseur commencera par afficher la fin de la chaine bien entendu
*/
void disp_browse(char phrase[], short col, short row, short dir, short cross) {
	short i = 0, o = 0, s = strlen(phrase);
	char *ptab = malloc(sizeof(char) * 4);

	if(!dir) {
		i = s - 1;
	}

	move(row, col);

	while(phrase[i] != '\0' || (i >= 0 && i < s)) {
		if(dir) {
			if(!cross)
				move(row + o, col);
			else
				move(row, col + o);
		}
		else {
			if(phrase[i] != '\xC2' && phrase[i - 1] != '\xC2') {
				if(phrase[i] != '\xE2' && phrase[i - 1] != '\xE2' && phrase[i - 2] != '\xE2') {
					addch(phrase[i]);
					refresh();
					o++;

					if(!cross)
						move(row - o, col);
					else
						move(row, col - o);
				}
			}
		}

		if((dir && phrase[i] == '\xC2') || (!dir && phrase[i] == '\xC2' && phrase[i - 1] != '\xC2')) {
			ptab[0] = phrase[i];
			ptab[1] = phrase[i + 1];
			ptab[2] = '\0';

			addstr(ptab);
			refresh();

			if(dir)
				i++;
			else {
				o++;

				if(!cross)
					move(row - o, col);
				else
					move(row, col - o);
			}
		}
		else if((dir && phrase[i] == '\xE2') || (!dir && phrase[i] == '\xE2' && phrase[i - 1] != '\xE2' && phrase[i - 2] != '\xE2')) {
			ptab[0] = phrase[i];
			ptab[1] = phrase[i + 1];
			ptab[2] = phrase[i + 2];
			ptab[3] = '\0';

			addstr(ptab);
			refresh();

			if(dir)
				i += 2;
			else {
				o++;

				if(!cross)
					move(row - o, col);
				else
					move(row, col - o);
			}
		}
		else if(dir) {
			addch(phrase[i]);
			refresh();
		}

		if(dir) {
			i++;
			o++;
		}
		else
			i--;
	}

	refresh();

	free(ptab);
}

void nom_couleur(int couleur, char *nom) {
	if(couleur == COLOR_WHITE)
		strcpy(nom, "BLANCHE");
	else if(couleur == COLOR_BLACK)
		strcpy(nom, "NOIRE");
	else if(couleur == COLOR_RED)
		strcpy(nom, "ROUGE");
	else if(couleur == COLOR_BLUE)
		strcpy(nom, "BLEUE");
	else if(couleur == COLOR_YELLOW)
		strcpy(nom, "JAUNE");
	else if(couleur == COLOR_GREEN)
		strcpy(nom, "VERTE");
	else if(couleur == COLOR_MAGENTA)
		strcpy(nom, "VIOLETTE");
	else if(couleur == COLOR_CYAN)
		strcpy(nom, "CYAN");
}

int couleur_nom(char *nom) {
	int couleur = 0;

	if(!strcmp(nom, "BLANCHE"))
		couleur = COLOR_WHITE;
	else if(!strcmp(nom, "NOIRE"))
		couleur = COLOR_BLACK;
	else if(!strcmp(nom, "ROUGE"))
		couleur = COLOR_RED;
	else if(!strcmp(nom, "BLEUE"))
		couleur = COLOR_BLUE;
	else if(!strcmp(nom, "JAUNE"))
		couleur = COLOR_YELLOW;
	else if(!strcmp(nom, "VERTE"))
		couleur = COLOR_GREEN;
	else if(!strcmp(nom, "VIOLETTE"))
		couleur = COLOR_MAGENTA;
	else if(!strcmp(nom, "CYAN"))
		couleur = COLOR_CYAN;

	return couleur;
}

void afficher_sous_titre(const char *titre, bool animation) {
	int lenght = strlen(titre), i, x[2], y;
	char *soulignage = malloc((lenght + 1) * sizeof(char));

	getyx(stdscr, y, x[2]);

	for(i = 0; i < lenght; i++) {
		soulignage[i] = '\xC4';
	}

	soulignage[lenght] = '\0';

	if(animation) {
		int lenght_debut_titre, lenght_fin_titre, temps_deplacement = 40, j = 0, taille_plus = 0;
		char debut_titre[lenght/2+1], fin_titre[lenght-lenght/2+1];
		bool attendre;


		for(i = 0; i < lenght / 2 || ((titre[i] & 0xc0) == 0x80); i++) { //Permet de ne pas couper un caractère UTF-8 en deux
			debut_titre[i] = titre[i];
			if(i >= lenght / 2)
				taille_plus++;
		}

		debut_titre[lenght/2] = '\0';

		for(i = lenght / 2 + taille_plus; i < lenght; i++) {
			fin_titre[j] = titre[i];
			j++;
		}

		fin_titre[lenght-lenght / 2] = '\0';

		lenght_debut_titre = strlen_utf8(debut_titre);
		lenght_fin_titre = strlen_utf8(fin_titre);

		x[0] = 0; //début du début du titre
		x[1] = DEFAULT_SCREEN_SIZE_X - lenght_fin_titre - 1; //début de la fin du titre

		if(lenght % 2 != 0) { //Corrige les problèmes avec les titres au nombre de caractères impaire
			lenght--;
		}

		mvaddstr(y + 1, x[0], debut_titre);
		mvaddstr(y + 1, x[1], fin_titre);

		for(i = 0; i != 60; i++) {
			attendre = false;

			if(x[0] != (x_begin_center(lenght))) {
				move(y + 1, 0);
				insch(' ');
				move(y + 1, DEFAULT_SCREEN_SIZE_X / 2);
				delch();
				x[0]++;
				attendre = true;
			}

			if(x[1] != x_begin_center(lenght) + lenght_debut_titre) {
				move(y + 1, DEFAULT_SCREEN_SIZE_X / 2);
				delch();
				x[1]--;
				attendre = true;
			}

			if(attendre) {
				refresh();
				CSLP_Sleep(temps_deplacement);

				if(temps_deplacement > 10) {
					temps_deplacement -= 1;
				}
			}
		}
		move(y + 1, 0);
		afficher_centre(titre); // Corrige l'affichage si il y a des caractères spéciaux
		move(y + 2, 0);
	}
	else {
		move(y + 1, 0);
		afficher_centre(titre);
	}

	souligner_centre(strlen_utf8(titre));
	move(y + 2, 0);
	refresh();
}

void afficher_temps(int y, int x, int type, long millisecondes) {
	long min = 0, sec = 0, recule = 0, i = 0;
	char texte[30];
	millisecondes -= millisecondes % 10;

	if(x != -1 && y != -1 && x != 'm') {
		move(y, x);
	}
	else if(x == 'm') {
		move(y, 0);
	}

	save_cursor_pos();

	while(millisecondes != 0) {
		CSLP_Sleep(10);
		millisecondes -= 10;
		sec = millisecondes / 1000;
		min = millisecondes / 60000;

		restore_cursor_pos();
		sprintf(texte, " %ld ", millisecondes);

		if(type == 1) {
			if(x != 'm') {
				recule = 3;
				addstr(texte);
			}
			else {
				afficher_centre(texte);
			}
		}
		else if(type == 2) {
			sprintf(texte, " %ld, %ld  ", sec, millisecondes % 1000);

			if(x != 'm') {
				recule = 4;
				addstr(texte);
			}
			else {
				afficher_centre(texte);
			}
		}
		else if(type == 3) {
			sprintf(texte, " %ld, %ld, %ld   ", min, sec % 60, millisecondes % 1000);

			if(x != 'm') {
				recule = 11;
				addstr(texte);
			}
			else {
				afficher_centre(texte);
			}
		}

		refresh();
	}

	restore_cursor_pos();

	while(i != recule) {
		addch(' ');
		i++;
	}
}

int get_time_ms(void) {
#ifdef _WIN32
	return clock();
#else

	struct timeval tv;

	gettimeofday(&tv, NULL);

	return tv.tv_sec * 1000 + tv.tv_usec / 1000;
#endif
}

int get_dif_time_ms(int *dernier_temps) {
	int temps, dif;

	temps = get_time_ms();

	dif = temps - *dernier_temps;
	*dernier_temps = temps;

	return dif;
}

void decaler(int nb, int temps, bool droite) {
	int i = 0;

	while(i != nb) {
		refresh();
		CSLP_Sleep(temps);

		if(droite) {
			insch(' ');
		}
		else {
			delch();
		}

		i++;
	}
}
